#obtenirStat <- function(file){   

debut <- Sys.time()

directory <- "/home/ceres/Temp/PFE/" 
list.file  <- dir(directory)

for(file in list.file){
  
  #========================================================
  # Lecture du fichier en entrée 
  requete <- read.csv(paste(directory,file,sep=""))
  
  #========================================================
  # Nombre de variables (concepts) dans le dataframe.
  nbvariables   <- length(names(requete))
  nomsVariables <- names(requete)

  # Nombre de lignes de la table
  nblignes <- nrow(requete)
  
  # Vecteur contenant les places des variables qualitatives
  vector.factor <- NULL
  vector.quanti <- NULL
  for(j in 1:nbvariables){
    if(is.factor(requete[,j])){
      vector.factor = c(vector.factor,j)
    }
    else{
      vector.quanti = c(vector.quanti,j)
    }
  }
  
  #========================================================
  # Remplacer toutes les valeurs manquantes marquées à ""
  # par des NA
  for(j in vector.factor){
    for(i in which(requete[,j]=="")){
      requete[i,j] <- NA
    }
  }
  
  # Compter le nombre de valeurs manquantes pour chaque 
  # variable. 
  count.NA = seq(nbvariables)
  for(j in 1:nbvariables){
    count.NA[j] = length(which(is.na(requete[,j])))
  }

  # On peut déjà à ce stade constituer le premier tableau d'information
  # sur la requete qui va servir à mettre à jour le fichier des ordres.
  concept.info <- data.frame(names(requete),count.NA,rep(nblignes,nbvariables))
  colnames(concept.info) <- c("concept","nbNA","nbLignes")
  
  #========================================================
  # Connaitre le nombre de modalités et les effectifs dans
  # chaque modalité pour chaque variable qualitative. 
  effectif.modalites      <- list()
  nbmodalites             <- NULL
  sd.effectif.modalites   <- NULL
  mean.effectif.modalites <- NULL
  for(j in vector.factor){
    table                   <- table(requete[,j])
    effectif.modalites      <- c(effectif.modalites,list(as.data.frame(table)))
    nbmodalites             <- c(nbmodalites,length(table))
    mean.effectif.modalites <- c(mean.effectif.modalites, mean(table))
    sd.effectif.modalites   <- c(sd.effectif.modalites, sd(table))
  }

  # ou bien le numéro de colonnes qui correspond (peut-etre
  # plus aisé à utiliser)
  names(effectif.modalites)      <- c(vector.factor)
  names(nbmodalites)             <- c(vector.factor)
  names(mean.effectif.modalites) <- c(vector.factor)
  names(sd.effectif.modalites)   <- c(vector.factor)
  
  #========================================================
  # La mesure que l'on a choisi de retenir
  mesureHomogeneite <- function(vecteur,k,p,N){
    return((p*k/N)*sum((vecteur - N/(k*p)^2)))
  }
  
  #========================================================
  # Mesure de l'effectif  près de l'idéal    
  intervalleEffectifOptimal <- function(vecteur,k,p,N){
    result <- as.vector(lapply(vecteur,function(x){(x >= (N/(k*p)-N/(k*p)*0.5)) && (x <= (N/(k*p)+N/(k*p)*0.5))}))
    resultat <- sum(t[which(result==TRUE)])
    return(resultat)
  }
  
  #========================================================
  # Permet d'obtenir toutes les modalités possibles pour 
  # toutes les variables contenues dans la table. 
  result.axe1 <- apply(requete,2,table)
  result.axe1 <- lapply(result.axe1,unlist)
  noms <- lapply(result.axe1,names)

  result.data <- NULL
  axe1 <- NULL
  axe2 <- NULL
  croisement.var       <- NULL
  croisement.homog     <- NULL
  croisement.eff       <- NULL

  # On effectue maintenant les croisements. Dans un premier
  # temps, on ne traite que le cas des variables qualitatives. 
  # On crée un vecteur contenant toutes les variables sur 
  # lesquelles on va effectivement effectuer les croisements :
  # - pas trop de valeurs manquantes
  variables.traitees1 <- which(count.NA < nblignes*0.30)
  # - pas trop de modalités
  variables.traitees2 <- which(lapply(noms,length) < nblignes/15)
  # On prend la synthèse des deux critères
  variables.traitees.quali  <- intersect(intersect(variables.traitees1,variables.traitees2),vector.factor)
  variables.traitees.quanti <- intersect(variables.traitees1,vector.quanti)

  variables.nontraitees.quali  <- setdiff(vector.factor,variables.traitees.quali)
  variables.nontraitees.quanti <- setdiff(vector.quanti, variables.traitees.quanti)
  
  # Le premier axe est une variable qualitative
  for(j in variables.traitees.quali){
    print("je suis du coté des quali")
    noms.temp = noms[[j]]
     
    # Le deuxième axe est une variable qualitative
    for(m in variables.traitees.quali){
      # Pour éviter de faire des croisements en double
      if(m > j){
        t <- NULL
        # On fait le croisement pour toutes les modalités de l'axe 1
        for(k in 1:length(noms.temp)){
          test  <- which(requete[,j]==noms.temp[k])
          test2 <- table(requete[test,m])
          t     <- c(t,test2)
        }
        # On retient toutes les informations pour ce croisement. 
        axe1 <- c(axe1,j)
        axe2 <- c(axe2,m)
        croisement.var       <- c(croisement.var, var(t))
        croisement.homog     <- c(croisement.homog,mesureHomogeneite(t,
                                                                    nbmodalites[as.character(j)],
                                                                    nbmodalites[as.character(m)],
                                                                    nblignes))
        croisement.eff       <- c(croisement.eff, intervalleEffectifOptimal(t,
                                                                    nbmodalites[as.character(j)],
                                                                    nbmodalites[as.character(m)],
                                                                    nblignes))
#        croisement.kpN       <- c(croisement.kpN,nbmodalites[as.character(j)]*nbmodalites[as.character(m)]/nblignes)
        print("j'ai fait un croisement Q * Q")      
      }      
    }
   
    # Le deuxième axe est une variable quantitative
    for(n in variables.traitees.quanti){
      # On calcule les bornes de découpage 
      quantile.temp <- unique(quantile(requete[,n], seq(0,1,by=0.10),na.rm=TRUE))
      t <- NULL
      # On fait le croisement pour toutes les modalités de l'axe 1
      for(k in 1:length(noms.temp)){
        test  <- which(requete[,j]==noms.temp[k])
        test2 <- table(cut(requete[test,n],quantile.temp))
        t     <- c(t,test2)
      }
      # On retient toutes les informations pour ce croisement.
      axe1 <- c(axe1,j)
      axe2 <- c(axe2,n)
      croisement.var       <- c(croisement.var,var(t))
      croisement.homog     <- c(croisement.homog,mesureHomogeneite(t,
                                                                  nbmodalites[as.character(j)],
                                                                  10,
                                                                  nblignes))
      croisement.eff       <- c(croisement.eff, intervalleEffectifOptimal(t,
                                                                  nbmodalites[as.character(j)],
                                                                  10,
                                                                  nblignes))
      #croisement.kpN       <- c(croisement.kpN,nblignes/(nbmodalites[as.character(j)]*10))
      print("j'ai fait un croisement Q * C")
    }
    
    Stat.max <- max(croisement.homog)
    Var.max  <- max(croisement.var)
    Eff.min  <- min(croisement.eff)
    
    for(o in variables.nontraitees.quali){
      axe1 <- c(axe1,j)
      axe2 <- c(axe2,o)
      croisement.var   <- c(croisement.var,Var.max)
      croisement.homog <- c(croisement.homog,Stat.max)
      croisement.eff   <- c(croisement.eff,Eff.min)
      print("j'ai fait un croisement Q * NQ")
    }
    
    for(o in variables.nontraitees.quanti){
      axe1 <- c(axe1,j)
      axe2 <- c(axe2,o)
      croisement.var   <- c(croisement.var,Var.max)
      croisement.homog <- c(croisement.homog,Stat.max)
      croisement.eff   <- c(croisement.eff,Eff.min)
      print("j'ai fait un croisement Q * NC")
    }
  }
  
  # On considère maintenant que le premier axe est quanti. 
  for(j in variables.traitees.quanti){
    # On calcule les bornes de découpage de j 
    quantile.temp.j <- unique(quantile(requete[,j], seq(0,1,by=1/4),na.rm=TRUE))
    
    for(n in variables.traitees.quanti){
      if( j > n ){
        # On calcule les bornes de découpage 
        quantile.temp <- unique(quantile(requete[,n], seq(0,1,by=1/4),na.rm=TRUE))
        t <- NULL
        # On fait le croisement selon les découpages des axes 1 et 2. 
        t <- as.vector(table(cut(requete[,j],quantile.temp.j),cut(requete[,n],quantile.temp)))
      
        # On retient toutes les informations pour ce croisement.
        axe1 <- c(axe1,j)
        axe2 <- c(axe2,n)
        croisement.var   <- c(croisement.var,var(t))
        croisement.homog     <- c(croisement.homog,mesureHomogeneite(t,
                                                                  4,
                                                                  4,
                                                                  nblignes))
        croisement.eff      <- c(croisement.eff,intervalleEffectifOptimal(t,
                                                                  4,
                                                                  4,
                                                                  nblignes))
        #croisement.kpN       <- c(croisement.kpN,nblignes/(4*4))   
        print("j'ai fait un croisement C * C")
      }
    }
    
    Stat.max <- max(croisement.homog)
    Var.max  <- max(croisement.var)
    Eff.min  <- min(croisement.eff)
    
    for(o in variables.nontraitees.quali){
      axe1 <- c(axe1,j)
      axe2 <- c(axe2,o)
      croisement.var   <- c(croisement.var,Var.max)
      croisement.homog <- c(croisement.homog,Stat.max)
      croisement.eff   <- c(croisement.eff,Eff.min)
      print("j'ai fait un croisement C * NQ")
    }
    
    for(o in variables.nontraitees.quanti){
      axe1 <- c(axe1,j)
      axe2 <- c(axe2,o)
      croisement.var   <- c(croisement.var,Var.max)
      croisement.homog <- c(croisement.homog,Stat.max)
      croisement.eff   <- c(croisement.eff,Eff.min)
      print("j'ai fait un croisement C * NC")
    }
  }
  
  for(j in variables.nontraitees.quanti){
    Stat.max <- max(croisement.homog)
    Var.max  <- max(croisement.var)
    Eff.min  <- min(croisement.eff)
    
    for(o in variables.nontraitees.quanti){
      print(o > j)
      if(o > j){
        axe1 <- c(axe1,j)
        axe2 <- c(axe2,o)
        croisement.var   <- c(croisement.var,Var.max)
        croisement.homog <- c(croisement.homog,Stat.max)
        croisement.eff   <- c(croisement.eff,Eff.min)
        print("j'ai fait un croisement NC * NC")        
      }
    }
    
    for(o in variables.nontraitees.quali){
      axe1 <- c(axe1,j)
      axe2 <- c(axe2,o)
      croisement.var   <- c(croisement.var,Var.max)
      croisement.homog <- c(croisement.homog,Stat.max)
      croisement.eff   <- c(croisement.eff,Eff.min)
      print("j'ai fait un croisement NC * NQ")
    }
  }
  
  for(j in variables.nontraitees.quali){
    Stat.max <- max(croisement.homog)
    Var.max  <- max(croisement.var)
    Eff.min  <- min(croisement.eff)
    
    for(o in variables.nontraitees.quali){
      print(paste(o,j," et "))
      if(o > j){
        axe1 <- c(axe1,j)
        axe2 <- c(axe2,o)
        croisement.var   <- c(croisement.var,Var.max)
        croisement.homog <- c(croisement.homog,Stat.max)
        croisement.eff   <- c(croisement.eff,Eff.min)
        print("j'ai fait un croisement NQ * NQ")
      }
      
    }
  }
  

  # On réinitialise la dataframe qui contiendra les résultats
  # des découpages obtenus (quels axes sont concernés, ainsi 
  # que les moyennes et les écarts types).
  result.data <- data.frame(axe1,axe2, croisement.homog,croisement.var,croisement.eff)
  
  #========================================================
  # Calcul des statistiques par axes.   
  aPourAxeEnPrincipal.Concept         <- NULL
  aPourAxeEnPrincipal.ConceptConcerne <- NULL
  aPourAxeEnPrincipal.Statistique     <- NULL
  aPourAxeEnPrincipal.nbChoix         <- NULL
  aPourAxeEnPrincipal.Classement      <- NULL

  aPourAxeEnComplementaire.Concept         <- NULL
  aPourAxeEnComplementaire.ConceptConcerne <- NULL
  aPourAxeEnComplementaire.Statistique     <- NULL
  aPourAxeEnComplementaire.nbChoix         <- NULL
  aPourAxeEnComplementaire.Classement      <- NULL

  # Pour chaque concept
  for(j in 1:nbvariables){
    stat.axe         <- numeric(nbvariables)
    nbApparition.axe <- numeric(nbvariables)
  
    # On calcule les stats sur le reste des axes. 
    for(i in 1:nrow(result.data)){
      if(j != i){
        stat.axe[result.data[i,"axe1"]] <- stat.axe[result.data[i,"axe1"]] + result.data[i,"croisement.homog"]
      
        stat.axe[result.data[i,"axe2"]] <- stat.axe[result.data[i,"axe2"]] + result.data[i,"croisement.homog"]
      }
    }
    
    #aPourAxeEnPrincipal.Classement      <- rank(aPourAxeEnPrincipal.Statistique, NA.last=TRUE, ties.method = "random")
    #aPourAxeEnComplementaire.Classement <- rank(aPourAxeEnComplementaire.Statistique, NA.last = TRUE, ties.method = "random")
    # On attribue le bon nom pour chaque stat. 
    if(j == 1){
      aPourAxeEnPrincipal.Concept         <- c(aPourAxeEnPrincipal.Concept,rep(nomsVariables[j],length(stat.axe)-1))
      aPourAxeEnPrincipal.ConceptConcerne <- c(aPourAxeEnPrincipal.ConceptConcerne,names(requete)[-j])
      aPourAxeEnPrincipal.Statistique     <- c(aPourAxeEnPrincipal.Statistique,stat.axe[-j])
    }
    else{
      aPourAxeEnComplementaire.Concept         <- c(aPourAxeEnComplementaire.Concept,rep(nomsVariables[j],length(stat.axe)-1))
      aPourAxeEnComplementaire.ConceptConcerne <- c(aPourAxeEnComplementaire.ConceptConcerne,names(requete)[-j])
      aPourAxeEnComplementaire.Statistique     <- c(aPourAxeEnComplementaire.Statistique,stat.axe[-j])
      
    }
  }
  
  print("Etape 1 de la constitution du tableau")

  # On met dans deux dataframes les résultats obtenus.   
  Principal <- data.frame(aPourAxeEnPrincipal.Concept,
                        aPourAxeEnPrincipal.ConceptConcerne,
                        aPourAxeEnPrincipal.Statistique)

  Complementaire <- data.frame(aPourAxeEnComplementaire.Concept,
                             aPourAxeEnComplementaire.ConceptConcerne, 
                             aPourAxeEnComplementaire.Statistique)
  
  print("Etape 2")
  # On rajoute le nombre de valeurs manquantes
  aPourAxeEnPrincipal.NA <- rep(0,nrow(Principal))
  for(i in 1:nrow(Principal)){
    aPourAxeEnPrincipal.NA[i] <- count.NA[Principal[i,"aPourAxeEnPrincipal.ConceptConcerne"]]
  }

  aPourAxeEnComplementaire.NA <- rep(0,nrow(Complementaire))
  for(i in 1:nrow(Complementaire)){
    aPourAxeEnComplementaire.NA[i] <- count.NA[Complementaire[i,"aPourAxeEnComplementaire.ConceptConcerne"]]
  }
  
  # On rajoute le classement 
  print("Etape 3")
  aPourAxeEnPrincipal.Classement      <- rank(aPourAxeEnPrincipal.Statistique, na.last=TRUE, ties.method = "random")
  aPourAxeEnComplementaire.Classement <- rank(aPourAxeEnComplementaire.Statistique, na.last = TRUE, ties.method = "random")
 

  Principal <- data.frame(Principal,aPourAxeEnPrincipal.NA, aPourAxeEnPrincipal.Classement)

  Complementaire <- data.frame(Complementaire,aPourAxeEnComplementaire.NA, aPourAxeEnComplementaire.Classement)
  
  #Complementaire <- Complementaire[order(Complementaire[,3],decreasing=FALSE),]
  #========================================================
  # Export des fichiers de résultat.
  print("juste avant d'écrire")
  directory.result <- "/home/ceres/Temp/PFE_Results/"
  concept.info.fileName  <- paste(strsplit(file,".csv"),"concept_info.csv",sep="_") 
  Complementaire.fileName <- paste(strsplit(file,".csv"),"complementaire.csv",sep="_")
  Principal.fileName      <- paste(strsplit(file,".csv"),"principal.csv",sep="_")

  write.table(concept.info, file = paste(directory.result,concept.info.fileName,sep=""), sep = ",", col.names = TRUE, row.names= FALSE,
            qmethod = "double")
  write.table(Complementaire, file = paste(directory.result,Complementaire.fileName,sep=""), sep = ",", col.names = TRUE, row.names= FALSE,
            qmethod = "double")  
  write.table(Principal, file = paste(directory.result,Principal.fileName,sep=""), sep = ",", col.names = TRUE, row.names= FALSE,
            qmethod = "double")
  
}
  Sys.time() - debut
#  }    